import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;

/**
 * GenericConverter 类 - 泛型转换工具类
 * 提供映射转换、反转顺序、排序等功能
 */
public class GenericConverter {
    // 学号绑定（根据要求添加）
    public static final String STUDENT_ID = "202411671451";

    /**
     * 映射转换方法
     * 使用 Function<T, R> 进行类型映射转换
     * 
     * @param <T>    源类型
     * @param <R>    目标类型
     * @param source 源容器
     * @param mapper 映射函数
     * @return 转换后的新容器
     */
    public static <T, R> DataContainer<R> convert(DataContainer<T> source, Function<T, R> mapper) {
        DataContainer<R> result = new DataContainer<>();
        for (int i = 0; i < source.size(); i++) {
            T element = source.get(i);
            R mappedElement = mapper.apply(element);
            result.add(mappedElement);
        }
        return result;
    }

    /**
     * 反转顺序方法
     * 返回新容器，确保原容器不变
     * 
     * @param <T>    元素类型
     * @param source 源容器
     * @return 反转顺序后的新容器
     */
    public static <T> DataContainer<T> reverse(DataContainer<T> source) {
        DataContainer<T> result = new DataContainer<>();
        // 从后往前遍历，实现反转
        for (int i = source.size() - 1; i >= 0; i--) {
            result.add(source.get(i));
        }
        return result;
    }

    /**
     * 自然排序方法
     * 元素需实现 Comparable 接口
     * 使用 Collections.sort() 算法，时间复杂度 O(n log n)
     * 
     * @param <T>    元素类型，必须实现 Comparable
     * @param source 源容器
     * @return 排序后的新容器
     */
    public static <T extends Comparable<? super T>> DataContainer<T> sort(DataContainer<T> source) {
        List<T> list = source.toList();
        // 使用 Collections.sort() 进行排序
        // 算法：TimSort（归并排序的优化版本）
        // 时间复杂度：O(n log n)
        // 空间复杂度：O(n)
        Collections.sort(list);

        DataContainer<T> result = new DataContainer<>(list);
        return result;
    }

    /**
     * 自定义排序方法
     * 使用自定义比较器进行排序
     * 使用 Collections.sort() 算法，时间复杂度 O(n log n)
     * 
     * @param <T>        元素类型
     * @param source     源容器
     * @param comparator 自定义比较器
     * @return 排序后的新容器
     */
    public static <T> DataContainer<T> sort(DataContainer<T> source, Comparator<? super T> comparator) {
        List<T> list = source.toList();
        // 使用 Collections.sort() 进行排序
        // 算法：TimSort（归并排序的优化版本）
        // 时间复杂度：O(n log n)
        // 空间复杂度：O(n)
        Collections.sort(list, comparator);

        DataContainer<T> result = new DataContainer<>(list);
        return result;
    }
}
